import java.util.Scanner;

class Person implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
//throws CloneNotSupportedException         一般放在方法声明的地方
public class Test {
    public static int func1(){
        try{
            return 10;
        }catch (NullPointerException e){

        }finally {
            return 100;//无论如何finally都会被执行，但不建议在finally中return
        }
    }
    public static void main(String[] args) {
        System.out.println(func1());
    }
    public static void main8(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        try {
            System.out.println(10 / a);
            int[] arr = null;
            System.out.println(arr.length);
        } catch (NullPointerException e) {
            e.printStackTrace();
        }finally {
            scanner.close();
            System.out.println("finally被执行");//不管是否发生异常都会被执行
        }
    }
    public static void main7(String[] args) {
        try {
            int[] arr = null;
            System.out.println(arr.length);
            System.out.println(10 / 0);
        }catch (ArithmeticException | NullPointerException e){      //不建议这样写，因为也太模糊了
            e.printStackTrace();//打印栈上的异常信息
            System.out.println("捕获到异常"+e);
        }
    }
    public static void main6(String[] args) {
        try {//程序只会同时抛出一个异常，不会同时抛出多个异常
            int[] arr = null;
            System.out.println(arr.length);
            System.out.println(10 / 0);
        }catch (ArithmeticException e){//注意子类在前父类在后
            System.out.println("捕获到算术异常"+e);
        }
        catch (NullPointerException e){
            System.out.println("捕获到空指针异常" + e);
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
    public static void main5(String[] args) {
        try {
            System.out.println(10 / 0);
            System.out.println("123456");//程序既然已经出现异常，证明你这个程序有问题，因此后面的代码也不会执行
        }catch (ArithmeticException e){//匹配不到又会交给JVM    不建议直接使用Exception,它是所有异常类的父类，这样写太模糊了
            System.out.println("捕获到算术异常"+e);
        }
        System.out.println("其他业务代码");
    }
    public static void main4(String[] args) {
        System.out.println(10/0);//这个异常没有被处理，程序会交给JVM处理，一旦交给JVM处理，代码就会异常中止，后面的代码不会被执行
        System.out.println("其他业务代码");
    }
    public static void test1 ()throws CloneNotSupportedException{
        int a = 10;
        if(a==10){
            throw new CloneNotSupportedException();
        }
    }

    public static void main3(String[] args) {
       try {
           test1();                //test1不处理异常需要调用者自行处理
       } catch (CloneNotSupportedException e) {
           throw new RuntimeException(e);
       }finally {
           System.out.println("异常处理程序");
       }
    }
    public static void main2(String[] args) {
        int a = 10;
        if(a==10){
            //多用于抛出自定义异常
            //抛出一个运行时异常时不需要处理的，但如果抛出的是编译时异常，我们需要去处理，最简单的处理方式是通过throws去处理
            throw new RuntimeException("a==10");
        }
    }
    public static void test(){
        test();//栈溢出异常
    }
    public static void main1(String[] args) throws CloneNotSupportedException {//不支持克隆异常
//        System.out.println(10/0);//算术异常
        //下标越界
       /* int[] arr = {1,2,3,4};
        System.out.println(arr[100]);*/
/*    Person person = new Person();
    Person person1 = (Person) person.clone();*/
        test();             //发生栈溢出错误
    }
}
